package com.ourteam.workspace.dao;

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import net.dao.BaseQueryBean;
import net.dao.BaseWhereCriterion;
import net.dao.IDataAccessInterface;
import org.apache.commons.lang.StringUtils;

/**
 * Template Name : DAO查询对象 Template Version : 1 Template Last Modfiy Date : Sat Aug 19 10:06:32 CST
 * 2017 Auto Generate Date : 2018-11-30 18:42:31 Warning ! This file will be overwrite when
 * regenerate !
 */
public class WorkspaceScmLogDAOQueryBean extends BaseQueryBean {

  public WorkspaceScmLogDAOQueryBean() {
    super();
  }

  public WorkspaceScmLogDAOQueryBean(BaseQueryBean aQueryBean) {
    super(aQueryBean);
  }

  public WorkspaceScmLogDAOQueryBean(BaseQueryBean aQueryBean, Map tableReplaceMap) {
    super(aQueryBean, tableReplaceMap);
  }

  public Criteria createCriteria() {

    Criteria criteria = createCriteriaInternal();
    if (oredCriteria.size() == 0) {
      oredCriteria.add(criteria);
    }
    return criteria;
  }

  protected Criteria createCriteriaInternal() {
    return new Criteria(this);
  }

  public void addIdSelectProperty() {
    addIdSelectProperty("id");
  }

  public void addIdSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceScmLogDAO.Id, aAlias);
    } else {
      addSelectProperty(IWorkspaceScmLogDAO.Id, "id");
    }
  }

  public void addParentIdSelectProperty() {
    addParentIdSelectProperty("parentId");
  }

  public void addParentIdSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceScmLogDAO.ParentId, aAlias);
    } else {
      addSelectProperty(IWorkspaceScmLogDAO.ParentId, "parentId");
    }
  }

  public void addWorkspaceIdSelectProperty() {
    addWorkspaceIdSelectProperty("workspaceId");
  }

  public void addWorkspaceIdSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceScmLogDAO.WorkspaceId, aAlias);
    } else {
      addSelectProperty(IWorkspaceScmLogDAO.WorkspaceId, "workspaceId");
    }
  }

  public void addWorkspaceScmConfigIdSelectProperty() {
    addWorkspaceScmConfigIdSelectProperty("workspaceScmConfigId");
  }

  public void addWorkspaceScmConfigIdSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceScmLogDAO.WorkspaceScmConfigId, aAlias);
    } else {
      addSelectProperty(IWorkspaceScmLogDAO.WorkspaceScmConfigId, "workspaceScmConfigId");
    }
  }

  public void addRevisionSelectProperty() {
    addRevisionSelectProperty("revision");
  }

  public void addRevisionSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceScmLogDAO.Revision, aAlias);
    } else {
      addSelectProperty(IWorkspaceScmLogDAO.Revision, "revision");
    }
  }

  public void addAuthorSelectProperty() {
    addAuthorSelectProperty("author");
  }

  public void addAuthorSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceScmLogDAO.Author, aAlias);
    } else {
      addSelectProperty(IWorkspaceScmLogDAO.Author, "author");
    }
  }

  public void addRevisionTimeSelectProperty() {
    addRevisionTimeSelectProperty("revisionTime");
  }

  public void addRevisionTimeSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceScmLogDAO.RevisionTime, aAlias);
    } else {
      addSelectProperty(IWorkspaceScmLogDAO.RevisionTime, "revisionTime");
    }
  }

  public void addCommentSelectProperty() {
    addCommentSelectProperty("comment");
  }

  public void addCommentSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceScmLogDAO.Comment, aAlias);
    } else {
      addSelectProperty(IWorkspaceScmLogDAO.Comment, "comment");
    }
  }

  public void addStatusSelectProperty() {
    addStatusSelectProperty("status");
  }

  public void addStatusSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceScmLogDAO.Status, aAlias);
    } else {
      addSelectProperty(IWorkspaceScmLogDAO.Status, "status");
    }
  }

  public void addRemarksSelectProperty() {
    addRemarksSelectProperty("remarks");
  }

  public void addRemarksSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceScmLogDAO.Remarks, aAlias);
    } else {
      addSelectProperty(IWorkspaceScmLogDAO.Remarks, "remarks");
    }
  }

  public void addTotalLinesSelectProperty() {
    addTotalLinesSelectProperty("totalLines");
  }

  public void addTotalLinesSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceScmLogDAO.TotalLines, aAlias);
    } else {
      addSelectProperty(IWorkspaceScmLogDAO.TotalLines, "totalLines");
    }
  }

  public void addTotalSizeSelectProperty() {
    addTotalSizeSelectProperty("totalSize");
  }

  public void addTotalSizeSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceScmLogDAO.TotalSize, aAlias);
    } else {
      addSelectProperty(IWorkspaceScmLogDAO.TotalSize, "totalSize");
    }
  }

  public void addWorkspaceNameSelectProperty() {
    addWorkspaceNameSelectProperty("workspaceName");
  }

  public void addWorkspaceNameSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceScmLogDAO.WorkspaceName, aAlias);
    } else {
      addSelectProperty(IWorkspaceScmLogDAO.WorkspaceName, "workspaceName");
    }
  }

  public void addAllSelectProperties() {

    addIdSelectProperty();

    addParentIdSelectProperty();

    addWorkspaceIdSelectProperty();

    addWorkspaceScmConfigIdSelectProperty();

    addRevisionSelectProperty();

    addAuthorSelectProperty();

    addRevisionTimeSelectProperty();

    addCommentSelectProperty();

    addStatusSelectProperty();

    addRemarksSelectProperty();

    addTotalLinesSelectProperty();

    addTotalSizeSelectProperty();

    addWorkspaceNameSelectProperty();
  }

  public static class Criteria extends BaseWhereCriterion<WorkspaceScmLogDAOQueryBean> {

    protected Criteria(WorkspaceScmLogDAOQueryBean aParentObject) {
      super(aParentObject);
    }

    public Criteria andIdIsNull() {
      addCriterion(IWorkspaceScmLogDAO.Id + " is null");
      return this;
    }

    public Criteria andIdIsNotNull() {
      addCriterion(IWorkspaceScmLogDAO.Id + " is not null");
      return this;
    }

    public Criteria andIdIsNotEmpty() {
      addCriterion(
          IWorkspaceScmLogDAO.Id + " is not null AND " + IWorkspaceScmLogDAO.Id + " <> ''");
      return this;
    }

    public Criteria andIdIsEmpty() {
      addCriterion(
          "(" + IWorkspaceScmLogDAO.Id + " is null OR " + IWorkspaceScmLogDAO.Id + " = '')");
      return this;
    }

    public Criteria andIdEqualTo(long value) {
      return andIdEqualTo(Long.valueOf(value));
    }

    public Criteria andIdEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceScmLogDAO.Id + " = ", value, "id");
      return this;
    }

    public Criteria andIdEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmLogDAO.Id);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andIdEqualTo(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.Id + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andIdNotEqualTo(long value) {
      return andIdNotEqualTo(Long.valueOf(value));
    }

    public Criteria andIdNotEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceScmLogDAO.Id + " <>", value, "id");
      return this;
    }

    public Criteria andIdNotEqualToOrIsNull(long value) {
      return andIdNotEqualToOrIsNull(Long.valueOf(value));
    }

    public Criteria andIdNotEqualToOrIsNull(java.lang.Long value) {

      addCriterion(
          IWorkspaceScmLogDAO.Id + " is null OR " + IWorkspaceScmLogDAO.Id + " <>", value, "id");
      return this;
    }

    public Criteria andIdNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmLogDAO.Id);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andIdNotEqualTo(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.Id + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andIdGreaterThan(long value) {
      return andIdGreaterThan(Long.valueOf(value));
    }

    public Criteria andIdGreaterThan(java.lang.Long value) {

      addCriterion(IWorkspaceScmLogDAO.Id + " >", value, "id");
      return this;
    }

    public Criteria andIdGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmLogDAO.Id);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andIdGreaterThan(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.Id + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andIdGreaterThanOrEqualTo(long value) {
      return andIdGreaterThanOrEqualTo(Long.valueOf(value));
    }

    public Criteria andIdGreaterThanOrEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceScmLogDAO.Id + " >=", value, "id");
      return this;
    }

    public Criteria andIdGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmLogDAO.Id);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andIdGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.Id + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andIdLessThan(long value) {
      return andIdLessThan(Long.valueOf(value));
    }

    public Criteria andIdLessThan(java.lang.Long value) {

      addCriterion(IWorkspaceScmLogDAO.Id + " <", value, "id");
      return this;
    }

    public Criteria andIdLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmLogDAO.Id);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andIdLessThan(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.Id + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andIdLessThanOrEqualTo(long value) {
      return andIdLessThanOrEqualTo(Long.valueOf(value));
    }

    public Criteria andIdLessThanOrEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceScmLogDAO.Id + " <=", value, "id");
      return this;
    }

    public Criteria andIdLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmLogDAO.Id);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andIdLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.Id + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andIdIn(long[] values) {
      if (values.length == 1) {
        return andIdEqualTo((java.lang.Long) values[0]);
      } else {
        addCriterion(IWorkspaceScmLogDAO.Id + " in", values, "id");
        return this;
      }
    }

    public Criteria andIdNotIn(long[] values) {
      if (values.length == 1) {
        return andIdNotEqualTo((java.lang.Long) values[0]);
      } else {
        addCriterion(IWorkspaceScmLogDAO.Id + " not in", values, "id");
        return this;
      }
    }

    public Criteria andIdIn(List<java.lang.Long> values) {

      if (values.size() == 1) {
        return andIdEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceScmLogDAO.Id + " in", values, "id");
        return this;
      }
    }

    public Criteria andIdNotIn(List<java.lang.Long> values) {
      if (values.size() == 1) {
        return andIdNotEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceScmLogDAO.Id + " not in", values, "id");
        return this;
      }
    }

    public Criteria andIdIn(java.lang.Long[] values) {

      if (values.length == 1) {
        return andIdEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceScmLogDAO.Id + " in", Arrays.asList(values), "id");
        return this;
      }
    }

    public Criteria andIdNotIn(java.lang.Long[] values) {
      if (values.length == 1) {
        return andIdNotEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceScmLogDAO.Id + " not in", Arrays.asList(values), "id");
        return this;
      }
    }

    public Criteria andIdIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.Id + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andIdNotIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.Id + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andIdBetween(long value1, long value2) {
      addCriterion(IWorkspaceScmLogDAO.Id + " between", value1, value2, "id");
      return this;
    }

    public Criteria andIdBetween(java.lang.Long value1, java.lang.Long value2) {
      addCriterion(IWorkspaceScmLogDAO.Id + " between", value1, value2, "id");
      return this;
    }

    public Criteria andIdNotBetween(long value1, long value2) {
      addCriterion(IWorkspaceScmLogDAO.Id + " not between", value1, value2, "id");
      return this;
    }

    public Criteria andIdNotBetween(java.lang.Long value1, java.lang.Long value2) {
      addCriterion(IWorkspaceScmLogDAO.Id + " not between", value1, value2, "id");
      return this;
    }

    public Criteria andParentIdIsNull() {
      addCriterion(IWorkspaceScmLogDAO.ParentId + " is null");
      return this;
    }

    public Criteria andParentIdIsNotNull() {
      addCriterion(IWorkspaceScmLogDAO.ParentId + " is not null");
      return this;
    }

    public Criteria andParentIdIsNotEmpty() {
      addCriterion(
          IWorkspaceScmLogDAO.ParentId
              + " is not null AND "
              + IWorkspaceScmLogDAO.ParentId
              + " <> ''");
      return this;
    }

    public Criteria andParentIdIsEmpty() {
      addCriterion(
          "("
              + IWorkspaceScmLogDAO.ParentId
              + " is null OR "
              + IWorkspaceScmLogDAO.ParentId
              + " = '')");
      return this;
    }

    public Criteria andParentIdEqualTo(long value) {
      return andParentIdEqualTo(Long.valueOf(value));
    }

    public Criteria andParentIdEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceScmLogDAO.ParentId + " = ", value, "parentId");
      return this;
    }

    public Criteria andParentIdEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmLogDAO.ParentId);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andParentIdEqualTo(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.ParentId + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andParentIdNotEqualTo(long value) {
      return andParentIdNotEqualTo(Long.valueOf(value));
    }

    public Criteria andParentIdNotEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceScmLogDAO.ParentId + " <>", value, "parentId");
      return this;
    }

    public Criteria andParentIdNotEqualToOrIsNull(long value) {
      return andParentIdNotEqualToOrIsNull(Long.valueOf(value));
    }

    public Criteria andParentIdNotEqualToOrIsNull(java.lang.Long value) {

      addCriterion(
          IWorkspaceScmLogDAO.ParentId + " is null OR " + IWorkspaceScmLogDAO.ParentId + " <>",
          value,
          "parentId");
      return this;
    }

    public Criteria andParentIdNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmLogDAO.ParentId);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andParentIdNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.ParentId + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andParentIdGreaterThan(long value) {
      return andParentIdGreaterThan(Long.valueOf(value));
    }

    public Criteria andParentIdGreaterThan(java.lang.Long value) {

      addCriterion(IWorkspaceScmLogDAO.ParentId + " >", value, "parentId");
      return this;
    }

    public Criteria andParentIdGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmLogDAO.ParentId);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andParentIdGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.ParentId + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andParentIdGreaterThanOrEqualTo(long value) {
      return andParentIdGreaterThanOrEqualTo(Long.valueOf(value));
    }

    public Criteria andParentIdGreaterThanOrEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceScmLogDAO.ParentId + " >=", value, "parentId");
      return this;
    }

    public Criteria andParentIdGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmLogDAO.ParentId);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andParentIdGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.ParentId + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andParentIdLessThan(long value) {
      return andParentIdLessThan(Long.valueOf(value));
    }

    public Criteria andParentIdLessThan(java.lang.Long value) {

      addCriterion(IWorkspaceScmLogDAO.ParentId + " <", value, "parentId");
      return this;
    }

    public Criteria andParentIdLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmLogDAO.ParentId);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andParentIdLessThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.ParentId + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andParentIdLessThanOrEqualTo(long value) {
      return andParentIdLessThanOrEqualTo(Long.valueOf(value));
    }

    public Criteria andParentIdLessThanOrEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceScmLogDAO.ParentId + " <=", value, "parentId");
      return this;
    }

    public Criteria andParentIdLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmLogDAO.ParentId);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andParentIdLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.ParentId + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andParentIdIn(long[] values) {
      if (values.length == 1) {
        return andParentIdEqualTo((java.lang.Long) values[0]);
      } else {
        addCriterion(IWorkspaceScmLogDAO.ParentId + " in", values, "parentId");
        return this;
      }
    }

    public Criteria andParentIdNotIn(long[] values) {
      if (values.length == 1) {
        return andParentIdNotEqualTo((java.lang.Long) values[0]);
      } else {
        addCriterion(IWorkspaceScmLogDAO.ParentId + " not in", values, "parentId");
        return this;
      }
    }

    public Criteria andParentIdIn(List<java.lang.Long> values) {

      if (values.size() == 1) {
        return andParentIdEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceScmLogDAO.ParentId + " in", values, "parentId");
        return this;
      }
    }

    public Criteria andParentIdNotIn(List<java.lang.Long> values) {
      if (values.size() == 1) {
        return andParentIdNotEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceScmLogDAO.ParentId + " not in", values, "parentId");
        return this;
      }
    }

    public Criteria andParentIdIn(java.lang.Long[] values) {

      if (values.length == 1) {
        return andParentIdEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceScmLogDAO.ParentId + " in", Arrays.asList(values), "parentId");
        return this;
      }
    }

    public Criteria andParentIdNotIn(java.lang.Long[] values) {
      if (values.length == 1) {
        return andParentIdNotEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceScmLogDAO.ParentId + " not in", Arrays.asList(values), "parentId");
        return this;
      }
    }

    public Criteria andParentIdIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.ParentId + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andParentIdNotIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.ParentId + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andParentIdBetween(long value1, long value2) {
      addCriterion(IWorkspaceScmLogDAO.ParentId + " between", value1, value2, "parentId");
      return this;
    }

    public Criteria andParentIdBetween(java.lang.Long value1, java.lang.Long value2) {
      addCriterion(IWorkspaceScmLogDAO.ParentId + " between", value1, value2, "parentId");
      return this;
    }

    public Criteria andParentIdNotBetween(long value1, long value2) {
      addCriterion(IWorkspaceScmLogDAO.ParentId + " not between", value1, value2, "parentId");
      return this;
    }

    public Criteria andParentIdNotBetween(java.lang.Long value1, java.lang.Long value2) {
      addCriterion(IWorkspaceScmLogDAO.ParentId + " not between", value1, value2, "parentId");
      return this;
    }

    public Criteria andWorkspaceIdIsNull() {
      addCriterion(IWorkspaceScmLogDAO.WorkspaceId + " is null");
      return this;
    }

    public Criteria andWorkspaceIdIsNotNull() {
      addCriterion(IWorkspaceScmLogDAO.WorkspaceId + " is not null");
      return this;
    }

    public Criteria andWorkspaceIdIsNotEmpty() {
      addCriterion(
          IWorkspaceScmLogDAO.WorkspaceId
              + " is not null AND "
              + IWorkspaceScmLogDAO.WorkspaceId
              + " <> ''");
      return this;
    }

    public Criteria andWorkspaceIdIsEmpty() {
      addCriterion(
          "("
              + IWorkspaceScmLogDAO.WorkspaceId
              + " is null OR "
              + IWorkspaceScmLogDAO.WorkspaceId
              + " = '')");
      return this;
    }

    public Criteria andWorkspaceIdEqualTo(long value) {
      return andWorkspaceIdEqualTo(Long.valueOf(value));
    }

    public Criteria andWorkspaceIdEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceScmLogDAO.WorkspaceId + " = ", value, "workspaceId");
      return this;
    }

    public Criteria andWorkspaceIdEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmLogDAO.WorkspaceId);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andWorkspaceIdEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.WorkspaceId + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceIdNotEqualTo(long value) {
      return andWorkspaceIdNotEqualTo(Long.valueOf(value));
    }

    public Criteria andWorkspaceIdNotEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceScmLogDAO.WorkspaceId + " <>", value, "workspaceId");
      return this;
    }

    public Criteria andWorkspaceIdNotEqualToOrIsNull(long value) {
      return andWorkspaceIdNotEqualToOrIsNull(Long.valueOf(value));
    }

    public Criteria andWorkspaceIdNotEqualToOrIsNull(java.lang.Long value) {

      addCriterion(
          IWorkspaceScmLogDAO.WorkspaceId
              + " is null OR "
              + IWorkspaceScmLogDAO.WorkspaceId
              + " <>",
          value,
          "workspaceId");
      return this;
    }

    public Criteria andWorkspaceIdNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmLogDAO.WorkspaceId);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andWorkspaceIdNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.WorkspaceId + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceIdGreaterThan(long value) {
      return andWorkspaceIdGreaterThan(Long.valueOf(value));
    }

    public Criteria andWorkspaceIdGreaterThan(java.lang.Long value) {

      addCriterion(IWorkspaceScmLogDAO.WorkspaceId + " >", value, "workspaceId");
      return this;
    }

    public Criteria andWorkspaceIdGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmLogDAO.WorkspaceId);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andWorkspaceIdGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.WorkspaceId + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceIdGreaterThanOrEqualTo(long value) {
      return andWorkspaceIdGreaterThanOrEqualTo(Long.valueOf(value));
    }

    public Criteria andWorkspaceIdGreaterThanOrEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceScmLogDAO.WorkspaceId + " >=", value, "workspaceId");
      return this;
    }

    public Criteria andWorkspaceIdGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmLogDAO.WorkspaceId);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andWorkspaceIdGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.WorkspaceId + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceIdLessThan(long value) {
      return andWorkspaceIdLessThan(Long.valueOf(value));
    }

    public Criteria andWorkspaceIdLessThan(java.lang.Long value) {

      addCriterion(IWorkspaceScmLogDAO.WorkspaceId + " <", value, "workspaceId");
      return this;
    }

    public Criteria andWorkspaceIdLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmLogDAO.WorkspaceId);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andWorkspaceIdLessThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.WorkspaceId + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceIdLessThanOrEqualTo(long value) {
      return andWorkspaceIdLessThanOrEqualTo(Long.valueOf(value));
    }

    public Criteria andWorkspaceIdLessThanOrEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceScmLogDAO.WorkspaceId + " <=", value, "workspaceId");
      return this;
    }

    public Criteria andWorkspaceIdLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmLogDAO.WorkspaceId);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andWorkspaceIdLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.WorkspaceId + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceIdIn(long[] values) {
      if (values.length == 1) {
        return andWorkspaceIdEqualTo((java.lang.Long) values[0]);
      } else {
        addCriterion(IWorkspaceScmLogDAO.WorkspaceId + " in", values, "workspaceId");
        return this;
      }
    }

    public Criteria andWorkspaceIdNotIn(long[] values) {
      if (values.length == 1) {
        return andWorkspaceIdNotEqualTo((java.lang.Long) values[0]);
      } else {
        addCriterion(IWorkspaceScmLogDAO.WorkspaceId + " not in", values, "workspaceId");
        return this;
      }
    }

    public Criteria andWorkspaceIdIn(List<java.lang.Long> values) {

      if (values.size() == 1) {
        return andWorkspaceIdEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceScmLogDAO.WorkspaceId + " in", values, "workspaceId");
        return this;
      }
    }

    public Criteria andWorkspaceIdNotIn(List<java.lang.Long> values) {
      if (values.size() == 1) {
        return andWorkspaceIdNotEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceScmLogDAO.WorkspaceId + " not in", values, "workspaceId");
        return this;
      }
    }

    public Criteria andWorkspaceIdIn(java.lang.Long[] values) {

      if (values.length == 1) {
        return andWorkspaceIdEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceScmLogDAO.WorkspaceId + " in", Arrays.asList(values), "workspaceId");
        return this;
      }
    }

    public Criteria andWorkspaceIdNotIn(java.lang.Long[] values) {
      if (values.length == 1) {
        return andWorkspaceIdNotEqualTo(values[0]);
      } else {
        addCriterion(
            IWorkspaceScmLogDAO.WorkspaceId + " not in", Arrays.asList(values), "workspaceId");
        return this;
      }
    }

    public Criteria andWorkspaceIdIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.WorkspaceId + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceIdNotIn(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.WorkspaceId + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceIdBetween(long value1, long value2) {
      addCriterion(IWorkspaceScmLogDAO.WorkspaceId + " between", value1, value2, "workspaceId");
      return this;
    }

    public Criteria andWorkspaceIdBetween(java.lang.Long value1, java.lang.Long value2) {
      addCriterion(IWorkspaceScmLogDAO.WorkspaceId + " between", value1, value2, "workspaceId");
      return this;
    }

    public Criteria andWorkspaceIdNotBetween(long value1, long value2) {
      addCriterion(IWorkspaceScmLogDAO.WorkspaceId + " not between", value1, value2, "workspaceId");
      return this;
    }

    public Criteria andWorkspaceIdNotBetween(java.lang.Long value1, java.lang.Long value2) {
      addCriterion(IWorkspaceScmLogDAO.WorkspaceId + " not between", value1, value2, "workspaceId");
      return this;
    }

    public Criteria andWorkspaceScmConfigIdIsNull() {
      addCriterion(IWorkspaceScmLogDAO.WorkspaceScmConfigId + " is null");
      return this;
    }

    public Criteria andWorkspaceScmConfigIdIsNotNull() {
      addCriterion(IWorkspaceScmLogDAO.WorkspaceScmConfigId + " is not null");
      return this;
    }

    public Criteria andWorkspaceScmConfigIdIsNotEmpty() {
      addCriterion(
          IWorkspaceScmLogDAO.WorkspaceScmConfigId
              + " is not null AND "
              + IWorkspaceScmLogDAO.WorkspaceScmConfigId
              + " <> ''");
      return this;
    }

    public Criteria andWorkspaceScmConfigIdIsEmpty() {
      addCriterion(
          "("
              + IWorkspaceScmLogDAO.WorkspaceScmConfigId
              + " is null OR "
              + IWorkspaceScmLogDAO.WorkspaceScmConfigId
              + " = '')");
      return this;
    }

    public Criteria andWorkspaceScmConfigIdEqualTo(long value) {
      return andWorkspaceScmConfigIdEqualTo(Long.valueOf(value));
    }

    public Criteria andWorkspaceScmConfigIdEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceScmLogDAO.WorkspaceScmConfigId + " = ", value, "workspaceScmConfigId");
      return this;
    }

    public Criteria andWorkspaceScmConfigIdEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmLogDAO.WorkspaceScmConfigId);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andWorkspaceScmConfigIdEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.WorkspaceScmConfigId + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceScmConfigIdNotEqualTo(long value) {
      return andWorkspaceScmConfigIdNotEqualTo(Long.valueOf(value));
    }

    public Criteria andWorkspaceScmConfigIdNotEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceScmLogDAO.WorkspaceScmConfigId + " <>", value, "workspaceScmConfigId");
      return this;
    }

    public Criteria andWorkspaceScmConfigIdNotEqualToOrIsNull(long value) {
      return andWorkspaceScmConfigIdNotEqualToOrIsNull(Long.valueOf(value));
    }

    public Criteria andWorkspaceScmConfigIdNotEqualToOrIsNull(java.lang.Long value) {

      addCriterion(
          IWorkspaceScmLogDAO.WorkspaceScmConfigId
              + " is null OR "
              + IWorkspaceScmLogDAO.WorkspaceScmConfigId
              + " <>",
          value,
          "workspaceScmConfigId");
      return this;
    }

    public Criteria andWorkspaceScmConfigIdNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmLogDAO.WorkspaceScmConfigId);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andWorkspaceScmConfigIdNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.WorkspaceScmConfigId + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceScmConfigIdGreaterThan(long value) {
      return andWorkspaceScmConfigIdGreaterThan(Long.valueOf(value));
    }

    public Criteria andWorkspaceScmConfigIdGreaterThan(java.lang.Long value) {

      addCriterion(IWorkspaceScmLogDAO.WorkspaceScmConfigId + " >", value, "workspaceScmConfigId");
      return this;
    }

    public Criteria andWorkspaceScmConfigIdGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmLogDAO.WorkspaceScmConfigId);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andWorkspaceScmConfigIdGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.WorkspaceScmConfigId + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceScmConfigIdGreaterThanOrEqualTo(long value) {
      return andWorkspaceScmConfigIdGreaterThanOrEqualTo(Long.valueOf(value));
    }

    public Criteria andWorkspaceScmConfigIdGreaterThanOrEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceScmLogDAO.WorkspaceScmConfigId + " >=", value, "workspaceScmConfigId");
      return this;
    }

    public Criteria andWorkspaceScmConfigIdGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmLogDAO.WorkspaceScmConfigId);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andWorkspaceScmConfigIdGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.WorkspaceScmConfigId + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceScmConfigIdLessThan(long value) {
      return andWorkspaceScmConfigIdLessThan(Long.valueOf(value));
    }

    public Criteria andWorkspaceScmConfigIdLessThan(java.lang.Long value) {

      addCriterion(IWorkspaceScmLogDAO.WorkspaceScmConfigId + " <", value, "workspaceScmConfigId");
      return this;
    }

    public Criteria andWorkspaceScmConfigIdLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmLogDAO.WorkspaceScmConfigId);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andWorkspaceScmConfigIdLessThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.WorkspaceScmConfigId + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceScmConfigIdLessThanOrEqualTo(long value) {
      return andWorkspaceScmConfigIdLessThanOrEqualTo(Long.valueOf(value));
    }

    public Criteria andWorkspaceScmConfigIdLessThanOrEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceScmLogDAO.WorkspaceScmConfigId + " <=", value, "workspaceScmConfigId");
      return this;
    }

    public Criteria andWorkspaceScmConfigIdLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmLogDAO.WorkspaceScmConfigId);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andWorkspaceScmConfigIdLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.WorkspaceScmConfigId + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceScmConfigIdIn(long[] values) {
      if (values.length == 1) {
        return andWorkspaceScmConfigIdEqualTo((java.lang.Long) values[0]);
      } else {
        addCriterion(
            IWorkspaceScmLogDAO.WorkspaceScmConfigId + " in", values, "workspaceScmConfigId");
        return this;
      }
    }

    public Criteria andWorkspaceScmConfigIdNotIn(long[] values) {
      if (values.length == 1) {
        return andWorkspaceScmConfigIdNotEqualTo((java.lang.Long) values[0]);
      } else {
        addCriterion(
            IWorkspaceScmLogDAO.WorkspaceScmConfigId + " not in", values, "workspaceScmConfigId");
        return this;
      }
    }

    public Criteria andWorkspaceScmConfigIdIn(List<java.lang.Long> values) {

      if (values.size() == 1) {
        return andWorkspaceScmConfigIdEqualTo(values.get(0));
      } else {
        addCriterion(
            IWorkspaceScmLogDAO.WorkspaceScmConfigId + " in", values, "workspaceScmConfigId");
        return this;
      }
    }

    public Criteria andWorkspaceScmConfigIdNotIn(List<java.lang.Long> values) {
      if (values.size() == 1) {
        return andWorkspaceScmConfigIdNotEqualTo(values.get(0));
      } else {
        addCriterion(
            IWorkspaceScmLogDAO.WorkspaceScmConfigId + " not in", values, "workspaceScmConfigId");
        return this;
      }
    }

    public Criteria andWorkspaceScmConfigIdIn(java.lang.Long[] values) {

      if (values.length == 1) {
        return andWorkspaceScmConfigIdEqualTo(values[0]);
      } else {
        addCriterion(
            IWorkspaceScmLogDAO.WorkspaceScmConfigId + " in",
            Arrays.asList(values),
            "workspaceScmConfigId");
        return this;
      }
    }

    public Criteria andWorkspaceScmConfigIdNotIn(java.lang.Long[] values) {
      if (values.length == 1) {
        return andWorkspaceScmConfigIdNotEqualTo(values[0]);
      } else {
        addCriterion(
            IWorkspaceScmLogDAO.WorkspaceScmConfigId + " not in",
            Arrays.asList(values),
            "workspaceScmConfigId");
        return this;
      }
    }

    public Criteria andWorkspaceScmConfigIdIn(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.WorkspaceScmConfigId + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceScmConfigIdNotIn(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.WorkspaceScmConfigId + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceScmConfigIdBetween(long value1, long value2) {
      addCriterion(
          IWorkspaceScmLogDAO.WorkspaceScmConfigId + " between",
          value1,
          value2,
          "workspaceScmConfigId");
      return this;
    }

    public Criteria andWorkspaceScmConfigIdBetween(java.lang.Long value1, java.lang.Long value2) {
      addCriterion(
          IWorkspaceScmLogDAO.WorkspaceScmConfigId + " between",
          value1,
          value2,
          "workspaceScmConfigId");
      return this;
    }

    public Criteria andWorkspaceScmConfigIdNotBetween(long value1, long value2) {
      addCriterion(
          IWorkspaceScmLogDAO.WorkspaceScmConfigId + " not between",
          value1,
          value2,
          "workspaceScmConfigId");
      return this;
    }

    public Criteria andWorkspaceScmConfigIdNotBetween(
        java.lang.Long value1, java.lang.Long value2) {
      addCriterion(
          IWorkspaceScmLogDAO.WorkspaceScmConfigId + " not between",
          value1,
          value2,
          "workspaceScmConfigId");
      return this;
    }

    public Criteria andRevisionIsNull() {
      addCriterion(IWorkspaceScmLogDAO.Revision + " is null");
      return this;
    }

    public Criteria andRevisionIsNotNull() {
      addCriterion(IWorkspaceScmLogDAO.Revision + " is not null");
      return this;
    }

    public Criteria andRevisionIsNotEmpty() {
      addCriterion(
          IWorkspaceScmLogDAO.Revision
              + " is not null AND "
              + IWorkspaceScmLogDAO.Revision
              + " <> ''");
      return this;
    }

    public Criteria andRevisionIsEmpty() {
      addCriterion(
          "("
              + IWorkspaceScmLogDAO.Revision
              + " is null OR "
              + IWorkspaceScmLogDAO.Revision
              + " = '')");
      return this;
    }

    public Criteria andRevisionEqualTo(String value) {

      addCriterion(IWorkspaceScmLogDAO.Revision + " = ", value, "revision");
      return this;
    }

    public Criteria andRevisionEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmLogDAO.Revision);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRevisionEqualTo(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.Revision + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andRevisionNotEqualTo(String value) {

      addCriterion(IWorkspaceScmLogDAO.Revision + " <>", value, "revision");
      return this;
    }

    public Criteria andRevisionNotEqualToOrIsNull(String value) {

      addCriterion(
          IWorkspaceScmLogDAO.Revision + " is null OR " + IWorkspaceScmLogDAO.Revision + " <>",
          value,
          "revision");
      return this;
    }

    public Criteria andRevisionNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmLogDAO.Revision);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRevisionNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.Revision + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andRevisionGreaterThan(String value) {

      addCriterion(IWorkspaceScmLogDAO.Revision + " >", value, "revision");
      return this;
    }

    public Criteria andRevisionGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmLogDAO.Revision);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRevisionGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.Revision + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andRevisionGreaterThanOrEqualTo(String value) {

      addCriterion(IWorkspaceScmLogDAO.Revision + " >=", value, "revision");
      return this;
    }

    public Criteria andRevisionGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmLogDAO.Revision);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRevisionGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.Revision + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andRevisionLessThan(String value) {

      addCriterion(IWorkspaceScmLogDAO.Revision + " <", value, "revision");
      return this;
    }

    public Criteria andRevisionLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmLogDAO.Revision);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRevisionLessThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.Revision + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andRevisionLessThanOrEqualTo(String value) {

      addCriterion(IWorkspaceScmLogDAO.Revision + " <=", value, "revision");
      return this;
    }

    public Criteria andRevisionLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmLogDAO.Revision);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRevisionLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.Revision + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andRevisionLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceScmLogDAO.Revision + " like", buffer.toString(), "revision");
      return this;
    }

    public Criteria andRevisionNotLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceScmLogDAO.Revision + " not like", buffer.toString(), "revision");
      return this;
    }

    public Criteria andRevisionIn(List<String> values) {

      if (values.size() == 1) {
        return andRevisionEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceScmLogDAO.Revision + " in", values, "revision");
        return this;
      }
    }

    public Criteria andRevisionNotIn(List<String> values) {
      if (values.size() == 1) {
        return andRevisionNotEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceScmLogDAO.Revision + " not in", values, "revision");
        return this;
      }
    }

    public Criteria andRevisionIn(String[] values) {

      if (values.length == 1) {
        return andRevisionEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceScmLogDAO.Revision + " in", Arrays.asList(values), "revision");
        return this;
      }
    }

    public Criteria andRevisionNotIn(String[] values) {
      if (values.length == 1) {
        return andRevisionNotEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceScmLogDAO.Revision + " not in", Arrays.asList(values), "revision");
        return this;
      }
    }

    public Criteria andRevisionIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.Revision + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andRevisionNotIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.Revision + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andRevisionBetween(String value1, String value2) {
      addCriterion(IWorkspaceScmLogDAO.Revision + " between", value1, value2, "revision");
      return this;
    }

    public Criteria andRevisionNotBetween(String value1, String value2) {
      addCriterion(IWorkspaceScmLogDAO.Revision + " not between", value1, value2, "revision");
      return this;
    }

    public Criteria andAuthorIsNull() {
      addCriterion(IWorkspaceScmLogDAO.Author + " is null");
      return this;
    }

    public Criteria andAuthorIsNotNull() {
      addCriterion(IWorkspaceScmLogDAO.Author + " is not null");
      return this;
    }

    public Criteria andAuthorIsNotEmpty() {
      addCriterion(
          IWorkspaceScmLogDAO.Author + " is not null AND " + IWorkspaceScmLogDAO.Author + " <> ''");
      return this;
    }

    public Criteria andAuthorIsEmpty() {
      addCriterion(
          "("
              + IWorkspaceScmLogDAO.Author
              + " is null OR "
              + IWorkspaceScmLogDAO.Author
              + " = '')");
      return this;
    }

    public Criteria andAuthorEqualTo(String value) {

      addCriterion(IWorkspaceScmLogDAO.Author + " = ", value, "author");
      return this;
    }

    public Criteria andAuthorEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmLogDAO.Author);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andAuthorEqualTo(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.Author + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andAuthorNotEqualTo(String value) {

      addCriterion(IWorkspaceScmLogDAO.Author + " <>", value, "author");
      return this;
    }

    public Criteria andAuthorNotEqualToOrIsNull(String value) {

      addCriterion(
          IWorkspaceScmLogDAO.Author + " is null OR " + IWorkspaceScmLogDAO.Author + " <>",
          value,
          "author");
      return this;
    }

    public Criteria andAuthorNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmLogDAO.Author);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andAuthorNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.Author + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andAuthorGreaterThan(String value) {

      addCriterion(IWorkspaceScmLogDAO.Author + " >", value, "author");
      return this;
    }

    public Criteria andAuthorGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmLogDAO.Author);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andAuthorGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.Author + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andAuthorGreaterThanOrEqualTo(String value) {

      addCriterion(IWorkspaceScmLogDAO.Author + " >=", value, "author");
      return this;
    }

    public Criteria andAuthorGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmLogDAO.Author);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andAuthorGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.Author + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andAuthorLessThan(String value) {

      addCriterion(IWorkspaceScmLogDAO.Author + " <", value, "author");
      return this;
    }

    public Criteria andAuthorLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmLogDAO.Author);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andAuthorLessThan(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.Author + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andAuthorLessThanOrEqualTo(String value) {

      addCriterion(IWorkspaceScmLogDAO.Author + " <=", value, "author");
      return this;
    }

    public Criteria andAuthorLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmLogDAO.Author);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andAuthorLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.Author + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andAuthorLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceScmLogDAO.Author + " like", buffer.toString(), "author");
      return this;
    }

    public Criteria andAuthorNotLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceScmLogDAO.Author + " not like", buffer.toString(), "author");
      return this;
    }

    public Criteria andAuthorIn(List<String> values) {

      if (values.size() == 1) {
        return andAuthorEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceScmLogDAO.Author + " in", values, "author");
        return this;
      }
    }

    public Criteria andAuthorNotIn(List<String> values) {
      if (values.size() == 1) {
        return andAuthorNotEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceScmLogDAO.Author + " not in", values, "author");
        return this;
      }
    }

    public Criteria andAuthorIn(String[] values) {

      if (values.length == 1) {
        return andAuthorEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceScmLogDAO.Author + " in", Arrays.asList(values), "author");
        return this;
      }
    }

    public Criteria andAuthorNotIn(String[] values) {
      if (values.length == 1) {
        return andAuthorNotEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceScmLogDAO.Author + " not in", Arrays.asList(values), "author");
        return this;
      }
    }

    public Criteria andAuthorIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.Author + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andAuthorNotIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.Author + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andAuthorBetween(String value1, String value2) {
      addCriterion(IWorkspaceScmLogDAO.Author + " between", value1, value2, "author");
      return this;
    }

    public Criteria andAuthorNotBetween(String value1, String value2) {
      addCriterion(IWorkspaceScmLogDAO.Author + " not between", value1, value2, "author");
      return this;
    }

    public Criteria andRevisionTimeIsNull() {
      addCriterion(IWorkspaceScmLogDAO.RevisionTime + " is null");
      return this;
    }

    public Criteria andRevisionTimeIsNotNull() {
      addCriterion(IWorkspaceScmLogDAO.RevisionTime + " is not null");
      return this;
    }

    public Criteria andRevisionTimeIsNotEmpty() {
      addCriterion(
          IWorkspaceScmLogDAO.RevisionTime
              + " is not null AND "
              + IWorkspaceScmLogDAO.RevisionTime
              + " <> ''");
      return this;
    }

    public Criteria andRevisionTimeIsEmpty() {
      addCriterion(
          "("
              + IWorkspaceScmLogDAO.RevisionTime
              + " is null OR "
              + IWorkspaceScmLogDAO.RevisionTime
              + " = '')");
      return this;
    }

    public Criteria andRevisionTimeEqualTo(java.util.Date value) {

      addCriterionForJDBCDate(IWorkspaceScmLogDAO.RevisionTime + " = ", value, "revisionTime");
      return this;
    }

    public Criteria andRevisionTimeEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmLogDAO.RevisionTime);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRevisionTimeEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.RevisionTime + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andRevisionTimeNotEqualTo(java.util.Date value) {

      addCriterionForJDBCDate(IWorkspaceScmLogDAO.RevisionTime + " <>", value, "revisionTime");
      return this;
    }

    public Criteria andRevisionTimeNotEqualToOrIsNull(java.util.Date value) {

      addCriterionForJDBCDate(
          IWorkspaceScmLogDAO.RevisionTime
              + " is null OR "
              + IWorkspaceScmLogDAO.RevisionTime
              + " <>",
          value,
          "revisionTime");
      return this;
    }

    public Criteria andRevisionTimeNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmLogDAO.RevisionTime);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRevisionTimeNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.RevisionTime + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andRevisionTimeGreaterThan(java.util.Date value) {

      addCriterionForJDBCDate(IWorkspaceScmLogDAO.RevisionTime + " >", value, "revisionTime");
      return this;
    }

    public Criteria andRevisionTimeGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmLogDAO.RevisionTime);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRevisionTimeGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.RevisionTime + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andRevisionTimeGreaterThanOrEqualTo(java.util.Date value) {

      addCriterionForJDBCDate(IWorkspaceScmLogDAO.RevisionTime + " >=", value, "revisionTime");
      return this;
    }

    public Criteria andRevisionTimeGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmLogDAO.RevisionTime);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRevisionTimeGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.RevisionTime + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andRevisionTimeLessThan(java.util.Date value) {

      addCriterionForJDBCDate(IWorkspaceScmLogDAO.RevisionTime + " <", value, "revisionTime");
      return this;
    }

    public Criteria andRevisionTimeLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmLogDAO.RevisionTime);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRevisionTimeLessThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.RevisionTime + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andRevisionTimeLessThanOrEqualTo(java.util.Date value) {

      addCriterionForJDBCDate(IWorkspaceScmLogDAO.RevisionTime + " <=", value, "revisionTime");
      return this;
    }

    public Criteria andRevisionTimeLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmLogDAO.RevisionTime);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRevisionTimeLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.RevisionTime + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andRevisionTimeIn(List<java.util.Date> values) {

      if (values.size() == 1) {
        return andRevisionTimeEqualTo(values.get(0));
      } else {
        addCriterionForJDBCDate(IWorkspaceScmLogDAO.RevisionTime + " in", values, "revisionTime");
        return this;
      }
    }

    public Criteria andRevisionTimeNotIn(List<java.util.Date> values) {
      if (values.size() == 1) {
        return andRevisionTimeNotEqualTo(values.get(0));
      } else {
        addCriterionForJDBCDate(
            IWorkspaceScmLogDAO.RevisionTime + " not in", values, "revisionTime");
        return this;
      }
    }

    public Criteria andRevisionTimeIn(java.util.Date[] values) {

      if (values.length == 1) {
        return andRevisionTimeEqualTo(values[0]);
      } else {
        addCriterionForJDBCDate(
            IWorkspaceScmLogDAO.RevisionTime + " in", Arrays.asList(values), "revisionTime");
        return this;
      }
    }

    public Criteria andRevisionTimeNotIn(java.util.Date[] values) {
      if (values.length == 1) {
        return andRevisionTimeNotEqualTo(values[0]);
      } else {
        addCriterionForJDBCDate(
            IWorkspaceScmLogDAO.RevisionTime + " not in", Arrays.asList(values), "revisionTime");
        return this;
      }
    }

    public Criteria andRevisionTimeIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.RevisionTime + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andRevisionTimeNotIn(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.RevisionTime + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andRevisionTimeBetween(java.util.Date value1, java.util.Date value2) {
      addCriterionForJDBCDate(
          IWorkspaceScmLogDAO.RevisionTime + " between", value1, value2, "revisionTime");
      return this;
    }

    public Criteria andRevisionTimeNotBetween(java.util.Date value1, java.util.Date value2) {
      addCriterionForJDBCDate(
          IWorkspaceScmLogDAO.RevisionTime + " not between", value1, value2, "revisionTime");
      return this;
    }

    public Criteria andCommentIsNull() {
      addCriterion(IWorkspaceScmLogDAO.Comment + " is null");
      return this;
    }

    public Criteria andCommentIsNotNull() {
      addCriterion(IWorkspaceScmLogDAO.Comment + " is not null");
      return this;
    }

    public Criteria andCommentIsNotEmpty() {
      addCriterion(
          IWorkspaceScmLogDAO.Comment
              + " is not null AND "
              + IWorkspaceScmLogDAO.Comment
              + " <> ''");
      return this;
    }

    public Criteria andCommentIsEmpty() {
      addCriterion(
          "("
              + IWorkspaceScmLogDAO.Comment
              + " is null OR "
              + IWorkspaceScmLogDAO.Comment
              + " = '')");
      return this;
    }

    public Criteria andCommentEqualTo(String value) {

      addCriterion(IWorkspaceScmLogDAO.Comment + " = ", value, "comment");
      return this;
    }

    public Criteria andCommentEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmLogDAO.Comment);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andCommentEqualTo(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.Comment + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andCommentNotEqualTo(String value) {

      addCriterion(IWorkspaceScmLogDAO.Comment + " <>", value, "comment");
      return this;
    }

    public Criteria andCommentNotEqualToOrIsNull(String value) {

      addCriterion(
          IWorkspaceScmLogDAO.Comment + " is null OR " + IWorkspaceScmLogDAO.Comment + " <>",
          value,
          "comment");
      return this;
    }

    public Criteria andCommentNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmLogDAO.Comment);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andCommentNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.Comment + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andCommentGreaterThan(String value) {

      addCriterion(IWorkspaceScmLogDAO.Comment + " >", value, "comment");
      return this;
    }

    public Criteria andCommentGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmLogDAO.Comment);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andCommentGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.Comment + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andCommentGreaterThanOrEqualTo(String value) {

      addCriterion(IWorkspaceScmLogDAO.Comment + " >=", value, "comment");
      return this;
    }

    public Criteria andCommentGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmLogDAO.Comment);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andCommentGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.Comment + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andCommentLessThan(String value) {

      addCriterion(IWorkspaceScmLogDAO.Comment + " <", value, "comment");
      return this;
    }

    public Criteria andCommentLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmLogDAO.Comment);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andCommentLessThan(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.Comment + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andCommentLessThanOrEqualTo(String value) {

      addCriterion(IWorkspaceScmLogDAO.Comment + " <=", value, "comment");
      return this;
    }

    public Criteria andCommentLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmLogDAO.Comment);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andCommentLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.Comment + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andCommentLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceScmLogDAO.Comment + " like", buffer.toString(), "comment");
      return this;
    }

    public Criteria andCommentNotLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceScmLogDAO.Comment + " not like", buffer.toString(), "comment");
      return this;
    }

    public Criteria andCommentIn(List<String> values) {

      if (values.size() == 1) {
        return andCommentEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceScmLogDAO.Comment + " in", values, "comment");
        return this;
      }
    }

    public Criteria andCommentNotIn(List<String> values) {
      if (values.size() == 1) {
        return andCommentNotEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceScmLogDAO.Comment + " not in", values, "comment");
        return this;
      }
    }

    public Criteria andCommentIn(String[] values) {

      if (values.length == 1) {
        return andCommentEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceScmLogDAO.Comment + " in", Arrays.asList(values), "comment");
        return this;
      }
    }

    public Criteria andCommentNotIn(String[] values) {
      if (values.length == 1) {
        return andCommentNotEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceScmLogDAO.Comment + " not in", Arrays.asList(values), "comment");
        return this;
      }
    }

    public Criteria andCommentIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.Comment + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andCommentNotIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.Comment + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andCommentBetween(String value1, String value2) {
      addCriterion(IWorkspaceScmLogDAO.Comment + " between", value1, value2, "comment");
      return this;
    }

    public Criteria andCommentNotBetween(String value1, String value2) {
      addCriterion(IWorkspaceScmLogDAO.Comment + " not between", value1, value2, "comment");
      return this;
    }

    public Criteria andStatusIsNull() {
      addCriterion(IWorkspaceScmLogDAO.Status + " is null");
      return this;
    }

    public Criteria andStatusIsNotNull() {
      addCriterion(IWorkspaceScmLogDAO.Status + " is not null");
      return this;
    }

    public Criteria andStatusIsNotEmpty() {
      addCriterion(
          IWorkspaceScmLogDAO.Status + " is not null AND " + IWorkspaceScmLogDAO.Status + " <> ''");
      return this;
    }

    public Criteria andStatusIsEmpty() {
      addCriterion(
          "("
              + IWorkspaceScmLogDAO.Status
              + " is null OR "
              + IWorkspaceScmLogDAO.Status
              + " = '')");
      return this;
    }

    public Criteria andStatusEqualTo(String value) {

      addCriterion(IWorkspaceScmLogDAO.Status + " = ", value, "status");
      return this;
    }

    public Criteria andStatusEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmLogDAO.Status);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andStatusEqualTo(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.Status + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andStatusNotEqualTo(String value) {

      addCriterion(IWorkspaceScmLogDAO.Status + " <>", value, "status");
      return this;
    }

    public Criteria andStatusNotEqualToOrIsNull(String value) {

      addCriterion(
          IWorkspaceScmLogDAO.Status + " is null OR " + IWorkspaceScmLogDAO.Status + " <>",
          value,
          "status");
      return this;
    }

    public Criteria andStatusNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmLogDAO.Status);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andStatusNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.Status + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andStatusGreaterThan(String value) {

      addCriterion(IWorkspaceScmLogDAO.Status + " >", value, "status");
      return this;
    }

    public Criteria andStatusGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmLogDAO.Status);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andStatusGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.Status + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andStatusGreaterThanOrEqualTo(String value) {

      addCriterion(IWorkspaceScmLogDAO.Status + " >=", value, "status");
      return this;
    }

    public Criteria andStatusGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmLogDAO.Status);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andStatusGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.Status + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andStatusLessThan(String value) {

      addCriterion(IWorkspaceScmLogDAO.Status + " <", value, "status");
      return this;
    }

    public Criteria andStatusLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmLogDAO.Status);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andStatusLessThan(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.Status + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andStatusLessThanOrEqualTo(String value) {

      addCriterion(IWorkspaceScmLogDAO.Status + " <=", value, "status");
      return this;
    }

    public Criteria andStatusLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmLogDAO.Status);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andStatusLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.Status + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andStatusLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceScmLogDAO.Status + " like", buffer.toString(), "status");
      return this;
    }

    public Criteria andStatusNotLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceScmLogDAO.Status + " not like", buffer.toString(), "status");
      return this;
    }

    public Criteria andStatusIn(List<String> values) {

      if (values.size() == 1) {
        return andStatusEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceScmLogDAO.Status + " in", values, "status");
        return this;
      }
    }

    public Criteria andStatusNotIn(List<String> values) {
      if (values.size() == 1) {
        return andStatusNotEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceScmLogDAO.Status + " not in", values, "status");
        return this;
      }
    }

    public Criteria andStatusIn(String[] values) {

      if (values.length == 1) {
        return andStatusEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceScmLogDAO.Status + " in", Arrays.asList(values), "status");
        return this;
      }
    }

    public Criteria andStatusNotIn(String[] values) {
      if (values.length == 1) {
        return andStatusNotEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceScmLogDAO.Status + " not in", Arrays.asList(values), "status");
        return this;
      }
    }

    public Criteria andStatusIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.Status + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andStatusNotIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.Status + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andStatusBetween(String value1, String value2) {
      addCriterion(IWorkspaceScmLogDAO.Status + " between", value1, value2, "status");
      return this;
    }

    public Criteria andStatusNotBetween(String value1, String value2) {
      addCriterion(IWorkspaceScmLogDAO.Status + " not between", value1, value2, "status");
      return this;
    }

    public Criteria andRemarksIsNull() {
      addCriterion(IWorkspaceScmLogDAO.Remarks + " is null");
      return this;
    }

    public Criteria andRemarksIsNotNull() {
      addCriterion(IWorkspaceScmLogDAO.Remarks + " is not null");
      return this;
    }

    public Criteria andRemarksIsNotEmpty() {
      addCriterion(
          IWorkspaceScmLogDAO.Remarks
              + " is not null AND "
              + IWorkspaceScmLogDAO.Remarks
              + " <> ''");
      return this;
    }

    public Criteria andRemarksIsEmpty() {
      addCriterion(
          "("
              + IWorkspaceScmLogDAO.Remarks
              + " is null OR "
              + IWorkspaceScmLogDAO.Remarks
              + " = '')");
      return this;
    }

    public Criteria andRemarksEqualTo(String value) {

      addCriterion(IWorkspaceScmLogDAO.Remarks + " = ", value, "remarks");
      return this;
    }

    public Criteria andRemarksEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmLogDAO.Remarks);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRemarksEqualTo(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.Remarks + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andRemarksNotEqualTo(String value) {

      addCriterion(IWorkspaceScmLogDAO.Remarks + " <>", value, "remarks");
      return this;
    }

    public Criteria andRemarksNotEqualToOrIsNull(String value) {

      addCriterion(
          IWorkspaceScmLogDAO.Remarks + " is null OR " + IWorkspaceScmLogDAO.Remarks + " <>",
          value,
          "remarks");
      return this;
    }

    public Criteria andRemarksNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmLogDAO.Remarks);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRemarksNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.Remarks + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andRemarksGreaterThan(String value) {

      addCriterion(IWorkspaceScmLogDAO.Remarks + " >", value, "remarks");
      return this;
    }

    public Criteria andRemarksGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmLogDAO.Remarks);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRemarksGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.Remarks + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andRemarksGreaterThanOrEqualTo(String value) {

      addCriterion(IWorkspaceScmLogDAO.Remarks + " >=", value, "remarks");
      return this;
    }

    public Criteria andRemarksGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmLogDAO.Remarks);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRemarksGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.Remarks + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andRemarksLessThan(String value) {

      addCriterion(IWorkspaceScmLogDAO.Remarks + " <", value, "remarks");
      return this;
    }

    public Criteria andRemarksLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmLogDAO.Remarks);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRemarksLessThan(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.Remarks + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andRemarksLessThanOrEqualTo(String value) {

      addCriterion(IWorkspaceScmLogDAO.Remarks + " <=", value, "remarks");
      return this;
    }

    public Criteria andRemarksLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmLogDAO.Remarks);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRemarksLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.Remarks + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andRemarksLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceScmLogDAO.Remarks + " like", buffer.toString(), "remarks");
      return this;
    }

    public Criteria andRemarksNotLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceScmLogDAO.Remarks + " not like", buffer.toString(), "remarks");
      return this;
    }

    public Criteria andRemarksIn(List<String> values) {

      if (values.size() == 1) {
        return andRemarksEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceScmLogDAO.Remarks + " in", values, "remarks");
        return this;
      }
    }

    public Criteria andRemarksNotIn(List<String> values) {
      if (values.size() == 1) {
        return andRemarksNotEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceScmLogDAO.Remarks + " not in", values, "remarks");
        return this;
      }
    }

    public Criteria andRemarksIn(String[] values) {

      if (values.length == 1) {
        return andRemarksEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceScmLogDAO.Remarks + " in", Arrays.asList(values), "remarks");
        return this;
      }
    }

    public Criteria andRemarksNotIn(String[] values) {
      if (values.length == 1) {
        return andRemarksNotEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceScmLogDAO.Remarks + " not in", Arrays.asList(values), "remarks");
        return this;
      }
    }

    public Criteria andRemarksIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.Remarks + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andRemarksNotIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.Remarks + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andRemarksBetween(String value1, String value2) {
      addCriterion(IWorkspaceScmLogDAO.Remarks + " between", value1, value2, "remarks");
      return this;
    }

    public Criteria andRemarksNotBetween(String value1, String value2) {
      addCriterion(IWorkspaceScmLogDAO.Remarks + " not between", value1, value2, "remarks");
      return this;
    }

    public Criteria andTotalLinesIsNull() {
      addCriterion(IWorkspaceScmLogDAO.TotalLines + " is null");
      return this;
    }

    public Criteria andTotalLinesIsNotNull() {
      addCriterion(IWorkspaceScmLogDAO.TotalLines + " is not null");
      return this;
    }

    public Criteria andTotalLinesIsNotEmpty() {
      addCriterion(
          IWorkspaceScmLogDAO.TotalLines
              + " is not null AND "
              + IWorkspaceScmLogDAO.TotalLines
              + " <> ''");
      return this;
    }

    public Criteria andTotalLinesIsEmpty() {
      addCriterion(
          "("
              + IWorkspaceScmLogDAO.TotalLines
              + " is null OR "
              + IWorkspaceScmLogDAO.TotalLines
              + " = '')");
      return this;
    }

    public Criteria andTotalLinesEqualTo(long value) {
      return andTotalLinesEqualTo(Long.valueOf(value));
    }

    public Criteria andTotalLinesEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceScmLogDAO.TotalLines + " = ", value, "totalLines");
      return this;
    }

    public Criteria andTotalLinesEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmLogDAO.TotalLines);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andTotalLinesEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.TotalLines + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andTotalLinesNotEqualTo(long value) {
      return andTotalLinesNotEqualTo(Long.valueOf(value));
    }

    public Criteria andTotalLinesNotEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceScmLogDAO.TotalLines + " <>", value, "totalLines");
      return this;
    }

    public Criteria andTotalLinesNotEqualToOrIsNull(long value) {
      return andTotalLinesNotEqualToOrIsNull(Long.valueOf(value));
    }

    public Criteria andTotalLinesNotEqualToOrIsNull(java.lang.Long value) {

      addCriterion(
          IWorkspaceScmLogDAO.TotalLines + " is null OR " + IWorkspaceScmLogDAO.TotalLines + " <>",
          value,
          "totalLines");
      return this;
    }

    public Criteria andTotalLinesNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmLogDAO.TotalLines);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andTotalLinesNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.TotalLines + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andTotalLinesGreaterThan(long value) {
      return andTotalLinesGreaterThan(Long.valueOf(value));
    }

    public Criteria andTotalLinesGreaterThan(java.lang.Long value) {

      addCriterion(IWorkspaceScmLogDAO.TotalLines + " >", value, "totalLines");
      return this;
    }

    public Criteria andTotalLinesGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmLogDAO.TotalLines);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andTotalLinesGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.TotalLines + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andTotalLinesGreaterThanOrEqualTo(long value) {
      return andTotalLinesGreaterThanOrEqualTo(Long.valueOf(value));
    }

    public Criteria andTotalLinesGreaterThanOrEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceScmLogDAO.TotalLines + " >=", value, "totalLines");
      return this;
    }

    public Criteria andTotalLinesGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmLogDAO.TotalLines);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andTotalLinesGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.TotalLines + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andTotalLinesLessThan(long value) {
      return andTotalLinesLessThan(Long.valueOf(value));
    }

    public Criteria andTotalLinesLessThan(java.lang.Long value) {

      addCriterion(IWorkspaceScmLogDAO.TotalLines + " <", value, "totalLines");
      return this;
    }

    public Criteria andTotalLinesLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmLogDAO.TotalLines);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andTotalLinesLessThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.TotalLines + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andTotalLinesLessThanOrEqualTo(long value) {
      return andTotalLinesLessThanOrEqualTo(Long.valueOf(value));
    }

    public Criteria andTotalLinesLessThanOrEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceScmLogDAO.TotalLines + " <=", value, "totalLines");
      return this;
    }

    public Criteria andTotalLinesLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmLogDAO.TotalLines);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andTotalLinesLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.TotalLines + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andTotalLinesIn(long[] values) {
      if (values.length == 1) {
        return andTotalLinesEqualTo((java.lang.Long) values[0]);
      } else {
        addCriterion(IWorkspaceScmLogDAO.TotalLines + " in", values, "totalLines");
        return this;
      }
    }

    public Criteria andTotalLinesNotIn(long[] values) {
      if (values.length == 1) {
        return andTotalLinesNotEqualTo((java.lang.Long) values[0]);
      } else {
        addCriterion(IWorkspaceScmLogDAO.TotalLines + " not in", values, "totalLines");
        return this;
      }
    }

    public Criteria andTotalLinesIn(List<java.lang.Long> values) {

      if (values.size() == 1) {
        return andTotalLinesEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceScmLogDAO.TotalLines + " in", values, "totalLines");
        return this;
      }
    }

    public Criteria andTotalLinesNotIn(List<java.lang.Long> values) {
      if (values.size() == 1) {
        return andTotalLinesNotEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceScmLogDAO.TotalLines + " not in", values, "totalLines");
        return this;
      }
    }

    public Criteria andTotalLinesIn(java.lang.Long[] values) {

      if (values.length == 1) {
        return andTotalLinesEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceScmLogDAO.TotalLines + " in", Arrays.asList(values), "totalLines");
        return this;
      }
    }

    public Criteria andTotalLinesNotIn(java.lang.Long[] values) {
      if (values.length == 1) {
        return andTotalLinesNotEqualTo(values[0]);
      } else {
        addCriterion(
            IWorkspaceScmLogDAO.TotalLines + " not in", Arrays.asList(values), "totalLines");
        return this;
      }
    }

    public Criteria andTotalLinesIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.TotalLines + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andTotalLinesNotIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.TotalLines + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andTotalLinesBetween(long value1, long value2) {
      addCriterion(IWorkspaceScmLogDAO.TotalLines + " between", value1, value2, "totalLines");
      return this;
    }

    public Criteria andTotalLinesBetween(java.lang.Long value1, java.lang.Long value2) {
      addCriterion(IWorkspaceScmLogDAO.TotalLines + " between", value1, value2, "totalLines");
      return this;
    }

    public Criteria andTotalLinesNotBetween(long value1, long value2) {
      addCriterion(IWorkspaceScmLogDAO.TotalLines + " not between", value1, value2, "totalLines");
      return this;
    }

    public Criteria andTotalLinesNotBetween(java.lang.Long value1, java.lang.Long value2) {
      addCriterion(IWorkspaceScmLogDAO.TotalLines + " not between", value1, value2, "totalLines");
      return this;
    }

    public Criteria andTotalSizeIsNull() {
      addCriterion(IWorkspaceScmLogDAO.TotalSize + " is null");
      return this;
    }

    public Criteria andTotalSizeIsNotNull() {
      addCriterion(IWorkspaceScmLogDAO.TotalSize + " is not null");
      return this;
    }

    public Criteria andTotalSizeIsNotEmpty() {
      addCriterion(
          IWorkspaceScmLogDAO.TotalSize
              + " is not null AND "
              + IWorkspaceScmLogDAO.TotalSize
              + " <> ''");
      return this;
    }

    public Criteria andTotalSizeIsEmpty() {
      addCriterion(
          "("
              + IWorkspaceScmLogDAO.TotalSize
              + " is null OR "
              + IWorkspaceScmLogDAO.TotalSize
              + " = '')");
      return this;
    }

    public Criteria andTotalSizeEqualTo(long value) {
      return andTotalSizeEqualTo(Long.valueOf(value));
    }

    public Criteria andTotalSizeEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceScmLogDAO.TotalSize + " = ", value, "totalSize");
      return this;
    }

    public Criteria andTotalSizeEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmLogDAO.TotalSize);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andTotalSizeEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.TotalSize + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andTotalSizeNotEqualTo(long value) {
      return andTotalSizeNotEqualTo(Long.valueOf(value));
    }

    public Criteria andTotalSizeNotEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceScmLogDAO.TotalSize + " <>", value, "totalSize");
      return this;
    }

    public Criteria andTotalSizeNotEqualToOrIsNull(long value) {
      return andTotalSizeNotEqualToOrIsNull(Long.valueOf(value));
    }

    public Criteria andTotalSizeNotEqualToOrIsNull(java.lang.Long value) {

      addCriterion(
          IWorkspaceScmLogDAO.TotalSize + " is null OR " + IWorkspaceScmLogDAO.TotalSize + " <>",
          value,
          "totalSize");
      return this;
    }

    public Criteria andTotalSizeNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmLogDAO.TotalSize);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andTotalSizeNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.TotalSize + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andTotalSizeGreaterThan(long value) {
      return andTotalSizeGreaterThan(Long.valueOf(value));
    }

    public Criteria andTotalSizeGreaterThan(java.lang.Long value) {

      addCriterion(IWorkspaceScmLogDAO.TotalSize + " >", value, "totalSize");
      return this;
    }

    public Criteria andTotalSizeGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmLogDAO.TotalSize);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andTotalSizeGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.TotalSize + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andTotalSizeGreaterThanOrEqualTo(long value) {
      return andTotalSizeGreaterThanOrEqualTo(Long.valueOf(value));
    }

    public Criteria andTotalSizeGreaterThanOrEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceScmLogDAO.TotalSize + " >=", value, "totalSize");
      return this;
    }

    public Criteria andTotalSizeGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmLogDAO.TotalSize);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andTotalSizeGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.TotalSize + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andTotalSizeLessThan(long value) {
      return andTotalSizeLessThan(Long.valueOf(value));
    }

    public Criteria andTotalSizeLessThan(java.lang.Long value) {

      addCriterion(IWorkspaceScmLogDAO.TotalSize + " <", value, "totalSize");
      return this;
    }

    public Criteria andTotalSizeLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmLogDAO.TotalSize);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andTotalSizeLessThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.TotalSize + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andTotalSizeLessThanOrEqualTo(long value) {
      return andTotalSizeLessThanOrEqualTo(Long.valueOf(value));
    }

    public Criteria andTotalSizeLessThanOrEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceScmLogDAO.TotalSize + " <=", value, "totalSize");
      return this;
    }

    public Criteria andTotalSizeLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmLogDAO.TotalSize);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andTotalSizeLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.TotalSize + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andTotalSizeIn(long[] values) {
      if (values.length == 1) {
        return andTotalSizeEqualTo((java.lang.Long) values[0]);
      } else {
        addCriterion(IWorkspaceScmLogDAO.TotalSize + " in", values, "totalSize");
        return this;
      }
    }

    public Criteria andTotalSizeNotIn(long[] values) {
      if (values.length == 1) {
        return andTotalSizeNotEqualTo((java.lang.Long) values[0]);
      } else {
        addCriterion(IWorkspaceScmLogDAO.TotalSize + " not in", values, "totalSize");
        return this;
      }
    }

    public Criteria andTotalSizeIn(List<java.lang.Long> values) {

      if (values.size() == 1) {
        return andTotalSizeEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceScmLogDAO.TotalSize + " in", values, "totalSize");
        return this;
      }
    }

    public Criteria andTotalSizeNotIn(List<java.lang.Long> values) {
      if (values.size() == 1) {
        return andTotalSizeNotEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceScmLogDAO.TotalSize + " not in", values, "totalSize");
        return this;
      }
    }

    public Criteria andTotalSizeIn(java.lang.Long[] values) {

      if (values.length == 1) {
        return andTotalSizeEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceScmLogDAO.TotalSize + " in", Arrays.asList(values), "totalSize");
        return this;
      }
    }

    public Criteria andTotalSizeNotIn(java.lang.Long[] values) {
      if (values.length == 1) {
        return andTotalSizeNotEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceScmLogDAO.TotalSize + " not in", Arrays.asList(values), "totalSize");
        return this;
      }
    }

    public Criteria andTotalSizeIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.TotalSize + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andTotalSizeNotIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.TotalSize + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andTotalSizeBetween(long value1, long value2) {
      addCriterion(IWorkspaceScmLogDAO.TotalSize + " between", value1, value2, "totalSize");
      return this;
    }

    public Criteria andTotalSizeBetween(java.lang.Long value1, java.lang.Long value2) {
      addCriterion(IWorkspaceScmLogDAO.TotalSize + " between", value1, value2, "totalSize");
      return this;
    }

    public Criteria andTotalSizeNotBetween(long value1, long value2) {
      addCriterion(IWorkspaceScmLogDAO.TotalSize + " not between", value1, value2, "totalSize");
      return this;
    }

    public Criteria andTotalSizeNotBetween(java.lang.Long value1, java.lang.Long value2) {
      addCriterion(IWorkspaceScmLogDAO.TotalSize + " not between", value1, value2, "totalSize");
      return this;
    }

    public Criteria andWorkspaceNameIsNull() {
      addCriterion(IWorkspaceScmLogDAO.WorkspaceName + " is null");
      return this;
    }

    public Criteria andWorkspaceNameIsNotNull() {
      addCriterion(IWorkspaceScmLogDAO.WorkspaceName + " is not null");
      return this;
    }

    public Criteria andWorkspaceNameIsNotEmpty() {
      addCriterion(
          IWorkspaceScmLogDAO.WorkspaceName
              + " is not null AND "
              + IWorkspaceScmLogDAO.WorkspaceName
              + " <> ''");
      return this;
    }

    public Criteria andWorkspaceNameIsEmpty() {
      addCriterion(
          "("
              + IWorkspaceScmLogDAO.WorkspaceName
              + " is null OR "
              + IWorkspaceScmLogDAO.WorkspaceName
              + " = '')");
      return this;
    }

    public Criteria andWorkspaceNameEqualTo(String value) {

      addCriterion(IWorkspaceScmLogDAO.WorkspaceName + " = ", value, "workspaceName");
      return this;
    }

    public Criteria andWorkspaceNameEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmLogDAO.WorkspaceName);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andWorkspaceNameEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.WorkspaceName + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceNameNotEqualTo(String value) {

      addCriterion(IWorkspaceScmLogDAO.WorkspaceName + " <>", value, "workspaceName");
      return this;
    }

    public Criteria andWorkspaceNameNotEqualToOrIsNull(String value) {

      addCriterion(
          IWorkspaceScmLogDAO.WorkspaceName
              + " is null OR "
              + IWorkspaceScmLogDAO.WorkspaceName
              + " <>",
          value,
          "workspaceName");
      return this;
    }

    public Criteria andWorkspaceNameNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmLogDAO.WorkspaceName);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andWorkspaceNameNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.WorkspaceName + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceNameGreaterThan(String value) {

      addCriterion(IWorkspaceScmLogDAO.WorkspaceName + " >", value, "workspaceName");
      return this;
    }

    public Criteria andWorkspaceNameGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmLogDAO.WorkspaceName);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andWorkspaceNameGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.WorkspaceName + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceNameGreaterThanOrEqualTo(String value) {

      addCriterion(IWorkspaceScmLogDAO.WorkspaceName + " >=", value, "workspaceName");
      return this;
    }

    public Criteria andWorkspaceNameGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmLogDAO.WorkspaceName);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andWorkspaceNameGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.WorkspaceName + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceNameLessThan(String value) {

      addCriterion(IWorkspaceScmLogDAO.WorkspaceName + " <", value, "workspaceName");
      return this;
    }

    public Criteria andWorkspaceNameLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmLogDAO.WorkspaceName);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andWorkspaceNameLessThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.WorkspaceName + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceNameLessThanOrEqualTo(String value) {

      addCriterion(IWorkspaceScmLogDAO.WorkspaceName + " <=", value, "workspaceName");
      return this;
    }

    public Criteria andWorkspaceNameLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmLogDAO.WorkspaceName);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andWorkspaceNameLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.WorkspaceName + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceNameLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceScmLogDAO.WorkspaceName + " like", buffer.toString(), "workspaceName");
      return this;
    }

    public Criteria andWorkspaceNameNotLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(
          IWorkspaceScmLogDAO.WorkspaceName + " not like", buffer.toString(), "workspaceName");
      return this;
    }

    public Criteria andWorkspaceNameIn(List<String> values) {

      if (values.size() == 1) {
        return andWorkspaceNameEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceScmLogDAO.WorkspaceName + " in", values, "workspaceName");
        return this;
      }
    }

    public Criteria andWorkspaceNameNotIn(List<String> values) {
      if (values.size() == 1) {
        return andWorkspaceNameNotEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceScmLogDAO.WorkspaceName + " not in", values, "workspaceName");
        return this;
      }
    }

    public Criteria andWorkspaceNameIn(String[] values) {

      if (values.length == 1) {
        return andWorkspaceNameEqualTo(values[0]);
      } else {
        addCriterion(
            IWorkspaceScmLogDAO.WorkspaceName + " in", Arrays.asList(values), "workspaceName");
        return this;
      }
    }

    public Criteria andWorkspaceNameNotIn(String[] values) {
      if (values.length == 1) {
        return andWorkspaceNameNotEqualTo(values[0]);
      } else {
        addCriterion(
            IWorkspaceScmLogDAO.WorkspaceName + " not in", Arrays.asList(values), "workspaceName");
        return this;
      }
    }

    public Criteria andWorkspaceNameIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.WorkspaceName + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceNameNotIn(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmLogDAO.WorkspaceName + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceNameBetween(String value1, String value2) {
      addCriterion(IWorkspaceScmLogDAO.WorkspaceName + " between", value1, value2, "workspaceName");
      return this;
    }

    public Criteria andWorkspaceNameNotBetween(String value1, String value2) {
      addCriterion(
          IWorkspaceScmLogDAO.WorkspaceName + " not between", value1, value2, "workspaceName");
      return this;
    }
  }
}
